#include "list.h"
/**
 *  功 能：
 *      创建并返回一个空的线性表
 *  参 数：
 *      capacity：线性表的最大的容量
 *  返回值：
 *      成功：一个空的线性表
 *      失败：NULL
 **/
seqList *List_create(int capacity)
{
    seqlist_t *head = NULL;
    head = (seqlist_t *)malloc(sizeof(seqlist_t));
    if (head == NULL)
    {
        printf("func create error, malloc error!\n");
        return NULL;
    }
    memset(head, 0, sizeof(seqlist_t));
    // 根据capacity的大小分配节点的空间
    head->node = (unsigned int **)malloc(sizeof(unsigned int *) * capacity);
    if (head->node == NULL)
    {
        printf("func create malloc error!\n");
        if (head != NULL)
            free(head);
        return NULL;
    }
    memset(head->node, 0, sizeof(unsigned int *) * capacity);

    head->capacity = capacity;
    head->length = 0;

    return head;
}
/**
 *  功 能：
 *      销毁一个线性表
 *  参 数：
 *      list：要操作的线性表
 *  返回值：
 *      成功：0
 *      失败：-1
 **/
status List_destory(seqList *list)
{
    if (list == NULL)
        return -1;
    seqlist_t *tlist = (seqlist_t *)list;
    // 先释放后开辟的内存空间
    if (tlist->node != NULL)
        free(tlist->node);
    free(tlist);
    return 0;
}
/**
 *  功 能：
 *      将一个线性表List中的所有元素清空，线性表回到
 *      创建时候的初始状态
 *  参 数：
 *      list：要操作的线性表
 *  返回值：
 *      成功：0
 *      失败：-1
 **/
status List_clear(seqList *list)
{
    if (list == NULL)
        return -1;
    seqlist_t *tlsit = (seqlist_t *)list;
    tlsit->length = 0;
    return 0;
}
/**
 *  功 能：
 *      返回一个线性表List中所有元素的个数
 *  参 数：
 *      list：要操作的线性表
 *  返回值：
 *      成功：线性表的长度
 *      失败：-1
 **/
int List_length(seqList *list)
{
    if (list == NULL)
        return -1;
    seqlist_t *tlsit = (seqlist_t *)list;
    return tlsit->length;
}
/**
 *  功 能：
 *      返回一个线性表List的最大容量
 *  参 数：
 *      list：要操作的线性表
 *  返回值：
 *      成功：线性表的最大容量
 *      失败：-1
 **/
int List_capacity(seqList *list)
{
    if (list == NULL)
        return -1;
    seqlist_t *tlsit = (seqlist_t *)list;
    return tlsit->capacity;
}

/**
 *  功 能：
 *      判断一个线性表List是否为空
 *  参 数：
 *      list：要操作的线性表
 *  返回值：
 *      为空：-1
 *      非空：0
 **/
status List_isEmpty(seqList *list)
{
    if (list == NULL)
        return -1;
    seqlist_t *tlsit = (seqlist_t *)list;
    return tlsit->length == 0 ? -1 : 0;
}
/**
 *  功 能：
 *      判断一个线性表List是否为满
 *  参 数：
 *      list：要操作的线性表
 *  返回值：
 *      为满：-1
 *      非满：0
 **/
status List_isFull(seqList *list)
{
    if (list == NULL)
        return -1;
    seqlist_t *tlsit = (seqlist_t *)list;
    return tlsit->length == tlsit->capacity ? -1 : 0;
}

/**
 *  功 能：
 *      向一个线性表List的pos位置插入新的元素
 *  参 数：
 *      list：要操作的线性表
 *      node：要插入的节点
 *      pos ：要插入的位置
 *  返回值：
 *      成功：0
 *      失败：-1
 *  注 意：
 *      链表的容量和链表的实际长度是不同的概念
 **/
status List_insert(seqList *list, ListNode *node, int pos)
{
    int i;
    seqlist_t *tlist = (seqlist_t *)list;
    if (list == NULL || node == NULL || pos < 0 || pos > tlist->capacity)
    {
        printf("func insert error, illegal parameter!\n");
        return -1;
    }
    // 当输入的参数大于当前顺序表中的元素数目，则将新插入的元素插入到最末尾
    if (pos > tlist->length)
    {
        pos = tlist->length;
    }
    // 1、判断是否为满
    if (List_isFull(list))
    {
        printf("func insert error, seqlinst is Full!\n");
        return -1;
    }
    // 2、元素后移
    for (i = tlist->length; i > pos; i--)
    {
        tlist->node[i] = tlist->node[i - 1];
    } // 3、插入参数
    tlist->node[i] = node;
    // 4、顺序表的长度更新
    tlist->length += 1;

    return 0;
}
/**
 *  功 能：
 *      获取一个线性表List的pos位置处的元素
 *      pos = 0           ： 表示为 头插法
 *      pos = List_length ：表示为尾插法
 *  参 数：
 *      list：要操作的线性表
 *      pos ：要插入的位置
 *  返回值：
 *      成功：节点
 *      失败：NULL
 **/
ListNode *List_get(seqList *list, int pos)
{
    seqlist_t *tlist = (seqlist_t *)list;
    if (list == NULL || pos < 0 || pos > tlist->capacity || pos > tlist->length)
    {
        printf("func get error, illegal parameter!\n");
        return NULL;
    }
    return (ListNode *)tlist->node[pos];
}
/**
 *  功 能：
 *      删除一个线性表List的pos位置处的元素
 *  参 数：
 *      list：要操作的线性表
 *      pos ：要插入的位置
 *  返回值：
 *      成功：被删除的元素
 *      失败：NULL
 **/
ListNode *List_delete(seqList *list, int pos)
{
    int i;
    seqlist_t *tlist = (seqlist_t *)list;
    // 参数判断
    if (tlist == NULL || pos < 0 || pos > tlist->capacity ||
        pos > tlist->length)
    {
        printf("func get error, illegal parameter!\n");
        return NULL;
    }
    if (List_isEmpty(list))
    {
        printf("func insert error, seqlinst is Empty!\n");
        return NULL;
    }
    // 缓存要删除的节点
    seqlist_t *tmp = (seqlist_t *)tlist->node[pos];
    // 依次前移元素
    for (i = pos + 1; i < tlist->length; i++)
    {
        tlist->node[i - 1] = tlist->node[i];
    }
    // 长度更新
    tlist->length--;

    return tmp;
}

funSeqList SeqListfunc = {List_create, List_destory, List_clear, List_length,
                          List_capacity, List_get, List_insert, List_delete,
                          List_isEmpty, List_isFull};
